#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <time.h>

// 定义蛋仔结构体，包含基本属性以及道具相关属性
typedef struct EggPlayer {
    char name[20];
    int attack;
    int defense;
    int live;
    int speed;
    int hasSpeedBoost;      // 加速道具，1表示有，0表示没有
    int speedBoostCount;    // 加速道具数量
    int hasInterference;    // 干扰道具，1表示有，0表示没有
    int interferenceCount;  // 干扰道具数量
    int hasTeleport;        // 瞬移道具，1表示有，0表示没有
    int teleportCount;      // 瞬移道具数量
    int hasShield;          // 护盾道具，1表示有，0表示没有
    int shieldCount;        // 护盾道具数量
} EggPlayer;

// 初始化蛋仔信息的函数，包含道具初始化逻辑
void initEggPlayer(EggPlayer *player, const char *name, int attack, int defense, int live, int speed) {
    strcpy(player->name, name);
    player->attack = attack;
    player->defense = defense;
    player->live = live;
    player->speed = speed;

    // 随机初始化道具数量，这里假设不同道具的初始获取概率和数量范围
    player->speedBoostCount = rand() % 2;  // 0 - 1个加速道具
    player->hasSpeedBoost = (player->speedBoostCount > 0);

    player->interferenceCount = rand() % 2;  // 0 - 1个干扰道具
    player->hasInterference = (player->interferenceCount > 0);

    player->teleportCount = rand() % 2;  // 0 - 1个瞬移道具
    player->hasTeleport = (player->teleportCount > 0);

    player->shieldCount = rand() % 2;  // 0 - 1个护盾道具
    player->hasShield = (player->shieldCount > 0);
}

// 蛋仔普通攻击函数，简单计算伤害并更新生命值
void normalAttack(EggPlayer *attacker, EggPlayer *defender) {
    int damage = attacker->attack - defender->defense;
    if (damage < 0) {
        damage = 0;
    }
    defender->live -= damage;
    if (defender->live < 0) {
        defender->live = 0;
	}
    printf("%s对%s进行了普通攻击，造成%d点伤害，%s剩余生命值为%d\n", attacker->name, defender->name, damage, defender->name, defender->live);
    if(defender->live<=0){
    	printf("%s已经死亡！\n",attacker->name,defender->live);
    }
}

// 1对1蛋仔对战逻辑函数，增加玩家选择行动顺序（觉得麻烦可以去掉，改成只有选择模式） 
void oneVsOneBattle(EggPlayer *player1, EggPlayer *player2) {
    int round = 1;
    int actionOrder;
    int i;  // 提前定义 i，用于后续可能的循环等操作，虽然此处暂未用到循环里，但保持统一规范
    printf("  {\\_/}\n");
    printf(" ( *-* )\n");
    printf("请选择行动顺序（1. %s 先行动，2. %s 先行动）：", player1->name, player2->name);
    scanf("%d", &actionOrder);

    while (player1->live > 0 && player2->live > 0) {
        printf("===== 1对1对战回合：第%d回合开始 =====", round);

        if (actionOrder == 1) {
            // 玩家1行动
            printf("\n%s行动：\n", player1->name);
            normalAttack(player1, player2);
            if (player2->live <= 0) {
                break;
            }

            // 玩家2行动
            printf("\n%s行动：\n", player2->name);
            normalAttack(player2, player1);
        } else {
            // 玩家2行动
            printf("\n%s行动：\n", player2->name);
            normalAttack(player2, player1);
            if (player1->live <= 0) {
                break;
            }

            // 玩家1行动
            printf("\n%s行动：\n", player1->name);
            normalAttack(player1, player2);
        }

        round++;
    }
    if (player1->live > 0) {
        printf("%s赢得了1对1对战回合！\n", player1->name);
    } else {
        printf("%s赢得了1对1对战回合！\n", player2->name);
    }
}

// 多人蛋仔混战逻辑函数，玩家可选择攻击目标
void multiBattle(EggPlayer players[], int numPlayers) {
    int round = 1;
    int i;  // 提前定义循环变量 i
    while (1) {
        int aliveCount = 0;
        for (i = 0; i < numPlayers; i++) {
            if (players[i].live > 0) {
                aliveCount++;
            }
        }
        if (aliveCount <= 1) {
            break;
        }

        printf("===== 多人混战回合：第%d回合开始 =====\n", round);

        // 每个存活的蛋仔依次行动
        for (i = 0; i < numPlayers; i++) {
            if (players[i].live > 0) {
                printf("\n%s行动：\n", players[i].name);
                int targetIndex;
                // 让玩家选择攻击目标，优化输入提示和错误处理
                do {
                	printf("  {\\_/}\n");
    				printf(" ( *-* )\n");
                    printf("请选择攻击目标（输入目标蛋仔编号，0是小粉 1是小蓝 2是小绿  0 - %d，不能攻击自己）：", numPlayers - 1);
                    if (scanf("%d", &targetIndex)!= 1) {
                        // 输入不是整数时的处理，清空输入缓冲区并提示重新输入
                        printf("输入有误，请输入整数哦，重新输入。\n");
                        while (getchar()!= '\n');
                        targetIndex = -1;  // 设置一个无效值，继续循环重新输入
                    }
                    printf("\n");
                } while (targetIndex == i || targetIndex < 0 || targetIndex >= numPlayers || players[targetIndex].live <= 0);
                normalAttack(&players[i], &players[targetIndex]);
            }
        }

        round++;
    }

    // 确定最终获胜者并输出结果
    for (i = 0; i < numPlayers; i++) {
        if (players[i].live > 0) {
            printf("%s赢得了多人混战回合！\n", players[i].name);
            break;
        }
    }
}

// 使用加速道具的函数，考虑道具数量和速度加倍效果
void useSpeedBoost(EggPlayer *player, int *position, int trackLength) {
    if (player->hasSpeedBoost && player->speedBoostCount > 0) {
        *position += player->speed + player->speed;  // 速度永久增加 
        player->speedBoostCount--;
		player->speed+=player->speed;
        if (player->speedBoostCount == 0) {
            player->hasSpeedBoost = 0;
        }
         
        printf("%s 使用了加速道具，速度加倍，当前位置：%d\n", player->name, *position);
        printf("%s当前速度：%d\n",player->name, *position); 
        if (*position > trackLength) {
            *position = trackLength;
        }
    } else {
        printf("%s 没有加速道具了，无法使用哦。\n", player->name);
    }
}

// 使用干扰道具的函数，使其他蛋仔速度减半，考虑道具数量
void useInterference(EggPlayer players[], int numPlayers, EggPlayer *user) {
    if (user->hasInterference && user->interferenceCount > 0) {
        int i;  // 提前定义循环变量 i
        for (i = 0; i < numPlayers; i++) {
            if (strcmp(players[i].name, user->name)!= 0) {
                players[i].speed = players[i].speed/2;
                printf("%s 的速度被 %s 的干扰道具影响，速度减半！\n", players[i].name, user->name);
                printf("%s当前速度：%d\n",players[i].name,players[i].speed);
            }
        }
        user->interferenceCount--;
        if (user->interferenceCount == 0) {
            user->hasInterference = 0;
        }
    } else {
        printf("%s 没有干扰道具了，无法使用哦。\n", user->name);
    }
}

// 使用瞬移道具的函数，直接移动到指定位置（这里假设移动到跑道一半位置，可调整）
void useTeleport(EggPlayer *player, int *position, int trackLength) {
    if (player->hasTeleport && player->teleportCount > 0) {
        *position = trackLength / 2;
        player->teleportCount--;
        if (player->teleportCount == 0) {
            player->hasTeleport = 0;
        }
        printf("%s 使用了瞬移道具，直接到达跑道中间位置，当前位置：%d\n", player->name, *position);
    } else {
        printf("%s 没有瞬移道具了，无法使用哦。\n", player->name);
    }
}

// 使用护盾道具的函数，开启护盾后一定回合内免疫负面效果
void useShield(EggPlayer *player) {
    if (player->hasShield && player->shieldCount > 0) {
        player->hasShield = 1;  // 开启护盾，这里假设开启后持续生效
        player->shieldCount--;
        if (player->shieldCount == 0) {
            player->hasShield = 0;
        }
        printf("%s 使用了护盾道具，已开启护盾，可免疫部分负面效果哦。\n", player->name);
    } else {
        printf("%s 没有护盾道具了，无法使用哦。\n", player->name);
    }
}

// 蛋仔跑图竞速逻辑函数，整合完善的道具系统使用逻辑，优化输入处理等
void eggRace(EggPlayer players[], int numPlayers) {
    int trackLength = 200;  // 简单设置固定跑图长度，可根据需要调整
    int positions[numPlayers];
    int i;  // 提前定义循环变量 i
    for (i = 0; i < numPlayers; i++) {
        positions[i] = 0;
    }
    int round = 1;
    while (1) {
        int allFinished = 1;
        for (i = 0; i < numPlayers; i++) {
            if (positions[i] < trackLength) {
                allFinished = 0;
                break;
            }
        }
        if (allFinished) {
            break;
        }
        printf("===== 跑图竞速回合：第%d回合开始 =====\n", round);

        // 每个蛋仔移动前询问是否使用道具以及使用哪种道具，优化输入处理和逻辑展示
        for (i = 0; i < numPlayers; i++) {
            if (positions[i] < trackLength) {
                printf("%s，当前你拥有以下道具：\n", players[i].name);
                if (players[i].hasSpeedBoost) {
                    printf(" 1 加速道具：%d个\n", players[i].speedBoostCount);
                }
                if (players[i].hasInterference) {
                    printf(" 2 干扰道具：%d个\n", players[i].interferenceCount);
                }
                if (players[i].hasTeleport) {
                    printf(" 3 瞬移道具：%d个\n", players[i].teleportCount);
                }
                if (players[i].hasShield) {
                    printf(" 4 护盾道具：%d个\n", players[i].shieldCount);
                }

                int choice;
                printf("请选择要使用的道具（0表示不使用道具）：");
                if (scanf("%d", &choice)!= 1) {
                    // 输入不是整数时的处理，清空输入缓冲区并提示重新输入
                    printf("输入有误，请输入整数哦，重新输入。\n");
                    while (getchar()!= '\n');
                    continue;
                }
                printf("\n");

                switch (choice) {
                case 0:
                    break;
                case 1:
                    if (players[i].hasSpeedBoost) {
                        useSpeedBoost(&players[i], &positions[i], trackLength);
                    } else {
                        printf("你没有加速道具呀，无法选择该道具哦，请重新选择。\n");
                        continue;
                    }
                    break;
                case 2:
                    if (players[i].hasInterference) {
                        useInterference(players, numPlayers, &players[i]);
                    } else {
                        printf("你没有干扰道具呀，无法选择该道具哦，请重新选择。\n");
                        continue;
                    }
                    break;
                case 3:
                    if (players[i].hasTeleport) {
                        useTeleport(&players[i], &positions[i], trackLength);
                    } else {
                        printf("你没有瞬移道具呀，无法选择该道具哦，请重新选择。\n");
                        continue;
                    }
                    break;
                case 4:
                    if (players[i].hasShield) {
                        useShield(&players[i]);
                    } else {
                        printf("你没有护盾道具呀，无法选择该道具哦，请重新选择。\n");
                        continue;
                    }
                    break;
                default:
                    printf("无效的选择，请重新选择要使用的道具（0表示不使用道具）：");
                    continue;
                }

                positions[i] += players[i].speed;
                if (positions[i] > trackLength) {
                    positions[i] = trackLength;
                }
                printf("%s 当前位置：%d\n", players[i].name, positions[i]);
            }
        }

        round++;
    }

    // 确定竞速获胜者
    int winnerIndex = 0;
    for (i = 1; i < numPlayers; i++) {
        if (positions[i] >= positions[winnerIndex]) {
            winnerIndex = i;
        }
    }
    printf("%s 在跑图竞速回合中获胜！\n", players[winnerIndex].name);
}

// 巅峰菜单函数，展示清晰的游戏操作菜单
void menu() {
    printf("请选择操作：\n1. 1对1对战\n2. 多人混战\n3. 蛋仔跑图竞速\n4. 退出\n");
    printf("\n");
}

// 验证输入的函数，返回验证后的有效输入值
int validateInput(const char* prompt, int min, int max) {
    int input;
    printf("%s", prompt);
    while (scanf("%d", &input)!= 1 || input < min || input > max) {
        // 清空输入缓冲区
        while (getchar()!= '\n');
        printf("输入无效，请重新输入范围在 %d - %d 的整数：", min, max);
    }
    return input;
}

// 处理游戏模式选择的函数
void handleGameModeChoice(EggPlayer allPlayers[3]) {
    int choice;
    do {
        menu();
        printf("请输入您的选择：");
        if (scanf("%d", &choice)!= 1) {
            // 输入不是整数时的处理，清空输入缓冲区并提示重新输入
            printf("输入有误，请输入整数哦，重新输入。\n");
            while (getchar()!= '\n');
            continue;
        }
        printf("\n");
        if (choice >= 1 && choice <= 3) {
            if (choice == 1) {
                oneVsOneBattle(&allPlayers[0], &allPlayers[1]);
            } else if (choice == 2) {
                multiBattle(allPlayers, 3);
            } else if (choice == 3) {
                eggRace(allPlayers, 3);
            }
        } else if (choice == 4) {
            printf("退出\n");
            main();
        } else {
            printf("无效的选择，请重新输入。\n");
        }
    } while (1);
}

int main() {
    int i, j;
    EggPlayer pinkEgg;
    EggPlayer blueEgg;
    EggPlayer greenEgg;
    
    printf("\n");
    printf("Loading, please wait\n");
    for (i = 1; i <= 100; i++) {
        for (j = 1; j <= i; j++)
            printf("*");
        printf("%d%%\r", i);
        Sleep(20);
    }
    printf("\n");
    printf("*************************************\n");
    printf("*                                   *\n");
    printf("*         欢迎来到蛋仔派对          *\n");
    printf("*                                   *\n");
    printf("*************************************\n");
    printf(" Please choose the mode you want\n");
    printf("  {\\_/}\n");
    printf(" ( *-* )\n");

    srand((unsigned int)time(NULL));
    // 初始化蛋仔信息
    initEggPlayer(&pinkEgg, "小粉", 30, 2, 100, 20);
    initEggPlayer(&blueEgg, "小蓝", 25, 3, 100, 15);
    initEggPlayer(&greenEgg, "小绿", 28, 2, 100, 25);
    EggPlayer allPlayers[3] = {pinkEgg, blueEgg, greenEgg};
	int mapChoice;
    int gameModeChoice;
    int levelChoice;
    int runOption;
    // 展示游戏模式选择菜单并获取用户输入
    printf("请选择游玩模式：\n");
    printf("0 - 巅峰模式\n");
    printf("1 - 乐园模式\n");
    printf("2 - 退出游戏\n");
    gameModeChoice = validateInput("请输入你的选择（0 - 2）：", 0, 2);
    printf("\n");
    switch (gameModeChoice) {
    case 0:
        handleGameModeChoice(allPlayers);
        break;
    case 1:
        
        // 乐园模式下展示地图选择菜单并获取用户输入
        printf("请选择乐园地图：\n");
        printf("1 - 图1：粉色温馨式 \n");
        printf("2 - 图2：跑酷休闲式\n");
        mapChoice = validateInput("请输入你的选择（1 - 2）：", 1, 2);

        switch (mapChoice) {
        case 1:
            
            printf("进入第一关\n");
            printf("请选择走 1:左边还是 2:右边\n");
            levelChoice = validateInput("请输入你的选择（1 - 左边，2 - 右边）：", 1, 2);

            if (levelChoice == 2) {
                // 这里可以补充走左边后续具体的关卡操作逻辑，暂省略详细代码
                printf("你选择了走左边");
                printf("你失败了！\n"); 
                main();
            } else if (levelChoice == 1) {
                printf("一直按住（1）键向前拉，走了5米，前方出现障碍，按住（1）向前拉 在点击五次（2）\n");
                Sleep(1 * 1000);
                printf("进入第二关的平台上，存档\n");
                Sleep(1 * 1000);
                printf("一直按住（1）键向前拉，走了5米，前方出现障碍，按住（1）向前拉 在点击五次（2）\n");
                Sleep(1 * 1000);
                printf("进入第三关的平台上，存档\n");
                Sleep(1 * 1000);
                printf("一直按住（1）键向前拉，走了5米，前方出现障碍，按住（1）向前拉 点击（2）跳起来的时候（1）后拉一下 （1）停 再按（1）摆正身体向前的方位 同样操作六次\n");
                Sleep(1 * 1000);
                printf("进入第四关的平台上，存档\n");
                Sleep(1 * 1000);
                printf("一直按住（1）键向前拉，走了5米，前方出现障碍，按住（1）向前拉 选择（左 中 右）（左右）一直按住（1）向前拉 （中）一直按住（1）向前拉点击（2）跳起来的时候（1）后拉一下 （1）停 再按（1）摆正身体向前的方位 同样操作五次\n");
                Sleep(1 * 1000);
                printf("进入第五关的平台上，存档\n");
                Sleep(1 * 1000);
                printf("一直按住（1）键向前拉，走了5米，前方出现障碍，按住（1）向前拉 在点击五次（2）\n");
                Sleep(1 * 1000);
                printf("进入第六关的平台上，存档\n");
                Sleep(1 * 1000);
                printf("一直按住（1）键向前拉，走了5米，前方出现障碍，按住（1）向前拉 先点击右（2）-左（2）-右（2）-左（2）-右（2）\n");
                Sleep(1 * 1000);
                printf("进入第七关的平台上，存档\n");
                Sleep(1 * 1000);
                printf("一直按住（1）键向前拉，走了5米，前方出现障碍，按住（1）向前拉\n");
                Sleep(1 * 1000);
                printf("进入第八关的平台上，存档\n");
                Sleep(1 * 1000);
                printf("一直按住（1）键向前拉，走了5米，前方出现障碍，按住（1）向前拉 再点击（2）平台可以坚持3s 要立即点击（2）并同时控制（1）向左前方拉\n");
                Sleep(1 * 1000);
                printf("通关成功\n");
                main();
            }
            break;
        case 2:
            
            printf("进入跑酷图啦\n");
            printf("请选择：\n");
            printf("1 - 进入跑酷\n");
            printf("2 - 铁蛋速通\n");
            runOption = validateInput("请输入你的选择（1 - 进入跑酷，2 - 铁蛋速通）：", 1, 2);

            switch (runOption) {
            case 1:
                printf("开始操作：\n");
                printf("按住（1）向前走3步  \n");
                Sleep(1 * 1000);
                printf("出现关卡\n");
                Sleep(1 * 1000);
                printf("按住(1) (2)边走边跳\n");
                Sleep(1 * 1000);
                printf("按住（1）向前走5步 存档\n");
                Sleep(1 * 1000);
                printf("来到第二关\n");
                Sleep(1 * 1000);
                printf("打开按钮出现关卡\n");
                Sleep(1 * 1000);
                printf("按住（1）向前走3步前拉并按住（2）（4）连着跳扑\n");
                Sleep(1 * 1000);
                printf("按住（1）向前走4步向前拉并按住（2）然后调整方向（2）右  （2）左  （2）右\n");
                Sleep(1 * 1000);
                printf("一直按住（1）向前\n");
                Sleep(1 * 1000);
                printf("走了10m找到黄色光条进入\n");
                Sleep(1 * 1000);
                printf("通关成功\n");
                main();
            case 2:
                printf("按住（1）向后走6步\n");
                printf("通关成功\n");
                main();
            }
            break;
        }
        break;
    case 2:
        printf("退出游戏\n");
        break;
    default:
        printf("无效的选择，请重新输入。\n");
        main();
    }

    return 0;
}